use proc_macro::TokenStream;
use syn::{Meta, Token};
use syn::parse::Parser;
use syn::punctuated::Punctuated;

fn parse_attribute_args(attr: TokenStream) {
    // 定义解析器：解析由逗号分隔的 Meta
    let parser = Punctuated::<Meta, Token![,]>::parse_terminated;

    // 解析输入属性
    let args = match parser.parse(attr) {
        Ok(args) => args,
        Err(_e) => return (),
    };

    // 处理解析后的参数
    for arg in args {
        match arg {
            Meta::Path(path) => {
                // 处理类似 `#[my_attr(some_flag)]` 中的标识符
                if path.is_ident("some_flag") {
                    // 生成相应的代码
                }
            }
            Meta::NameValue(nv) => {
                // 处理类似 `#[my_attr(name = "value")]` 中的键值对
                if nv.path.is_ident("name") {
                    if let syn::Expr::Lit(lit_str) = &nv.value {
                        let _value = lit_str.lit.clone();
                        // 使用 value 生成代码
                    }
                }
            }
            Meta::List(list) => {
                // 处理嵌套列表，例如 `#[my_attr(nested(a, b))]`
                // 可以进一步解析 list.nested
            }
        }
    }
}

pub fn to_upper_name(str: &str)-> String {
    let mut is_upper = true;
    str.chars().into_iter().map(|c| {
        if c == '_' {
            is_upper = true;
            return None;
        }
        if is_upper {
            is_upper = false;
            Some(c.to_ascii_uppercase())
        } else {
            Some(c)
        }
    }).filter(|t| t.is_some()).map(|t| t.unwrap()).collect()
}

#[cfg(test)]
mod test {
    use log::info;
    use crate::util::to_upper_name;

    #[test]
    pub fn test_to_upper_name() {
        let method_name = to_upper_name("test_to_upper_name");
        assert_eq!("TestToUpperName", method_name);
        info!("new method name: {}", method_name);
    }
}